﻿
using System;
using System.Collections.Generic;

using System.Text;

namespace Rance.Battle
{
    class 步卒AI : AI
    {
        public int 守护基数 { get; set; }

        public override AIResult Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            AIResult result = new AIResult();

            var 盾击 = 技能mgt.Get("盾击");
            bool has盾击目标 = 盾击 != null;

            #region 复仇之刃

            if (技能mgt.Has("复仇之刃"))
            {
                int 生命比率 = 角色.兵力 * 100 / 角色.最大兵力;
                if (生命比率 <= 20)
                {
                    var 复仇之刃 = 技能mgt.Get("复仇之刃");
                    var 复仇之刃target = get复仇之刃Target(ConvertSoloTarget(复仇之刃.TargetList), 队伍状况);
                    if (复仇之刃target != null)
                    {
                        result.Action = 复仇之刃.Name;
                        result.TargetList.Add(复仇之刃target);

                        return result;
                    }
                }
            }

            #endregion

            #region 守护

            //优先守护队友
            //1   自己有守护率时,使用守护概率+30
            //2   没有队友(包括自己)有守护率时,使用守护为100
            //3   1个队友有守护率时,守护概率=90
            //4   2个队友有守护率时,守护概率=70
            //5   3个队友有守护率时,守护概率=40
            //5   4个队友有守护率时,守护概率=20
            //6   剩下自己时,守护概率=0
            //7   剩下2人时,守护概率-50
            //7   剩下3人时,守护概率-20

            int 守护概率 = 守护基数;
            var 守护队友人数 = 队伍状况.队伍.成员List.FindAll(r => (r.守护率 > 0 || r.全体守护率 > 0) && r != 角色).Count;

            switch (守护队友人数)
            {
                case 0:
                    守护概率 = 100;
                    break;
                case 1:
                    守护概率 = 90;
                    break;
                case 2:
                    守护概率 = 70;
                    break;
                case 3:
                    守护概率 = 40;
                    break;
                case 4:
                    守护概率 = 20;
                    break;
            }
            if (角色.守护率 > 0 || 角色.全体守护率 > 0)
                守护概率 += 30;
            
            var 可行动队友数量 = 队伍状况.队伍.成员List.FindAll(r => !r.是否完结).Count;
            switch (可行动队友数量)
            {
                case 1:
                    守护概率 = 0;
                    break;
                case 2:
                    守护概率 -= 50;
                    break;
                case 3:
                    守护概率 -= 20;
                    break;
            }

            if (!has盾击目标)
                守护概率 += 200;

            bool 是否守护 = false;
            if (守护概率 >= 100)
                是否守护 = true;
            else if (守护概率 > 0)
                是否守护 = 队伍状况.战场.AI乱数表.Hit(守护概率);

            if (是否守护)
            {
                if (技能mgt.Has("后发制人"))
                {
                    if (角色.行动点 >= 2 && 角色.全体守护率 == 0)
                    {
                        var 后发制人 = 技能mgt.Get("后发制人");
                        result.Action = 后发制人.Name;
                        result.TargetList.Add(角色);

                        return result;
                    }
                }

                if (技能mgt.Has("守护队友"))
                {
                    var 守护队友 = 技能mgt.Get("守护队友");
                    result.Action = 守护队友.Name;
                    result.TargetList.Add(角色);

                    return result;
                }
                else if (技能mgt.Has("守护全体队友"))
                {
                    var 守护全体队友 = 技能mgt.Get("守护全体队友");
                    result.Action = 守护全体队友.Name;
                    result.TargetList.Add(角色);

                    return result;
                }
            }

            #endregion

            #region 枪袭

            if (技能mgt.Has("枪袭"))
            {
                if (角色.行动点 >= 2)
                {
                    var 枪袭 = 技能mgt.Get("枪袭");
                    var 枪袭target = getTarget(ConvertSoloTarget(枪袭.TargetList), 队伍状况);
                    result.Action = 枪袭.Name;
                    result.TargetList.Add(枪袭target);

                    return result;
                }
            }

            #endregion

            #region 盾击

            var 盾击target = getTarget(ConvertSoloTarget(盾击.TargetList), 队伍状况);
            result.Action = 盾击.Name;
            result.TargetList.Add(盾击target);

            return result;
            
            #endregion
        }

        private 角色 get复仇之刃Target(List<角色> targetList, 队伍状况 队伍状况)
        {
            targetList.Sort((v1, v2) => v1.兵力.CompareTo(v2.兵力));
            if (targetList.Count == 0)
                return null;
            else
                return targetList[targetList.Count - 1];

        }

        private 角色 getTarget(List<角色> targetList, 队伍状况 队伍状况)
        {
            List<角色> tempList = targetList.FindAll(r => r.是否准备);
            if (tempList.Count == 1)
                return targetList[0];
            else if (tempList.Count > 1)
            {
                var value = 队伍状况.战场.AI乱数表.Random(0, tempList.Count);
                return tempList[value];
            }

            //撇除"步卒"敌人
            tempList.Clear();
            foreach (var item in targetList)
            {
                if (item.兵种.类型 == "步卒")
                    continue;

                tempList.Add(item);
            }

            if (tempList.Count != 0)
                targetList = tempList;

            if (targetList.Count == 1)
                return targetList[0];
            else
            {
                var value = 队伍状况.战场.AI乱数表.Random(0, targetList.Count);
                return targetList[value];
            }
        }

        private static 步卒AI instance = new 步卒AI();
        public static 步卒AI GetInstance()
        {
            return instance;
        }
    }
}
